/*
 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.awt.geom;

import java.io.Serializable;

/**
 * <CODE>Arc2D</CODE> is the abstract superclass for all objects that
 * store a 2D arc defined by a framing rectangle,
 * start angle, angular extent (length of the arc), and a closure type
 * (<CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>).
 * <p>
 * <a name="inscribes">
 * The arc is a partial section of a full ellipse which
 * inscribes the framing rectangle of its parent {@link RectangularShape}.
 * </a>
 * <a name="angles">
 * The angles are specified relative to the non-square
 * framing rectangle such that 45 degrees always falls on the line from
 * the center of the ellipse to the upper right corner of the framing
 * rectangle.
 * As a result, if the framing rectangle is noticeably longer along one
 * axis than the other, the angles to the start and end of the arc segment
 * will be skewed farther along the longer axis of the frame.
 * </a>
 * <p>
 * The actual storage representation of the coordinates is left to
 * the subclass.
 *
 * @author Jim Graham
 * @since 1.2
 */
public abstract class Arc2D extends RectangularShape {

  /**
   * The closure type for an open arc with no path segments
   * connecting the two ends of the arc segment.
   *
   * @since 1.2
   */
  public final static int OPEN = 0;

  /**
   * The closure type for an arc closed by drawing a straight
   * line segment from the start of the arc segment to the end of the
   * arc segment.
   *
   * @since 1.2
   */
  public final static int CHORD = 1;

  /**
   * The closure type for an arc closed by drawing straight line
   * segments from the start of the arc segment to the center
   * of the full ellipse and from that point to the end of the arc segment.
   *
   * @since 1.2
   */
  public final static int PIE = 2;

  /**
   * This class defines an arc specified in {@code float} precision.
   *
   * @since 1.2
   */
  public static class Float extends Arc2D implements Serializable {

    /**
     * The X coordinate of the upper-left corner of the framing
     * rectangle of the arc.
     *
     * @serial
     * @since 1.2
     */
    public float x;

    /**
     * The Y coordinate of the upper-left corner of the framing
     * rectangle of the arc.
     *
     * @serial
     * @since 1.2
     */
    public float y;

    /**
     * The overall width of the full ellipse of which this arc is
     * a partial section (not considering the
     * angular extents).
     *
     * @serial
     * @since 1.2
     */
    public float width;

    /**
     * The overall height of the full ellipse of which this arc is
     * a partial section (not considering the
     * angular extents).
     *
     * @serial
     * @since 1.2
     */
    public float height;

    /**
     * The starting angle of the arc in degrees.
     *
     * @serial
     * @since 1.2
     */
    public float start;

    /**
     * The angular extent of the arc in degrees.
     *
     * @serial
     * @since 1.2
     */
    public float extent;

    /**
     * Constructs a new OPEN arc, initialized to location (0, 0),
     * size (0, 0), angular extents (start = 0, extent = 0).
     *
     * @since 1.2
     */
    public Float() {
      super(OPEN);
    }

    /**
     * Constructs a new arc, initialized to location (0, 0),
     * size (0, 0), angular extents (start = 0, extent = 0), and
     * the specified closure type.
     *
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Float(int type) {
      super(type);
    }

    /**
     * Constructs a new arc, initialized to the specified location,
     * size, angular extents, and closure type.
     *
     * @param x The X coordinate of the upper-left corner of the arc's framing rectangle.
     * @param y The Y coordinate of the upper-left corner of the arc's framing rectangle.
     * @param w The overall width of the full ellipse of which this arc is a partial section.
     * @param h The overall height of the full ellipse of which this arc is a partial section.
     * @param start The starting angle of the arc in degrees.
     * @param extent The angular extent of the arc in degrees.
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Float(float x, float y, float w, float h,
        float start, float extent, int type) {
      super(type);
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.start = start;
      this.extent = extent;
    }

    /**
     * Constructs a new arc, initialized to the specified location,
     * size, angular extents, and closure type.
     *
     * @param ellipseBounds The framing rectangle that defines the outer boundary of the full
     * ellipse of which this arc is a partial section.
     * @param start The starting angle of the arc in degrees.
     * @param extent The angular extent of the arc in degrees.
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Float(Rectangle2D ellipseBounds,
        float start, float extent, int type) {
      super(type);
      this.x = (float) ellipseBounds.getX();
      this.y = (float) ellipseBounds.getY();
      this.width = (float) ellipseBounds.getWidth();
      this.height = (float) ellipseBounds.getHeight();
      this.start = start;
      this.extent = extent;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getX() {
      return (double) x;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getY() {
      return (double) y;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getWidth() {
      return (double) width;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getHeight() {
      return (double) height;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getAngleStart() {
      return (double) start;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getAngleExtent() {
      return (double) extent;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public boolean isEmpty() {
      return (width <= 0.0 || height <= 0.0);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setArc(double x, double y, double w, double h,
        double angSt, double angExt, int closure) {
      this.setArcType(closure);
      this.x = (float) x;
      this.y = (float) y;
      this.width = (float) w;
      this.height = (float) h;
      this.start = (float) angSt;
      this.extent = (float) angExt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setAngleStart(double angSt) {
      this.start = (float) angSt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setAngleExtent(double angExt) {
      this.extent = (float) angExt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    protected Rectangle2D makeBounds(double x, double y,
        double w, double h) {
      return new Rectangle2D.Float((float) x, (float) y,
          (float) w, (float) h);
    }

    /*
     * JDK 1.6 serialVersionUID
     */
    private static final long serialVersionUID = 9130893014586380278L;

    /**
     * Writes the default serializable fields to the
     * <code>ObjectOutputStream</code> followed by a byte
     * indicating the arc type of this <code>Arc2D</code>
     * instance.
     *
     * @serialData <ol> <li>The default serializable fields. <li> followed by a <code>byte</code>
     * indicating the arc type {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. </ol>
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
      s.defaultWriteObject();

      s.writeByte(getArcType());
    }

    /**
     * Reads the default serializable fields from the
     * <code>ObjectInputStream</code> followed by a byte
     * indicating the arc type of this <code>Arc2D</code>
     * instance.
     *
     * @serialData <ol> <li>The default serializable fields. <li> followed by a <code>byte</code>
     * indicating the arc type {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. </ol>
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.lang.ClassNotFoundException, java.io.IOException {
      s.defaultReadObject();

      try {
        setArcType(s.readByte());
      } catch (IllegalArgumentException iae) {
        throw new java.io.InvalidObjectException(iae.getMessage());
      }
    }
  }

  /**
   * This class defines an arc specified in {@code double} precision.
   *
   * @since 1.2
   */
  public static class Double extends Arc2D implements Serializable {

    /**
     * The X coordinate of the upper-left corner of the framing
     * rectangle of the arc.
     *
     * @serial
     * @since 1.2
     */
    public double x;

    /**
     * The Y coordinate of the upper-left corner of the framing
     * rectangle of the arc.
     *
     * @serial
     * @since 1.2
     */
    public double y;

    /**
     * The overall width of the full ellipse of which this arc is
     * a partial section (not considering the angular extents).
     *
     * @serial
     * @since 1.2
     */
    public double width;

    /**
     * The overall height of the full ellipse of which this arc is
     * a partial section (not considering the angular extents).
     *
     * @serial
     * @since 1.2
     */
    public double height;

    /**
     * The starting angle of the arc in degrees.
     *
     * @serial
     * @since 1.2
     */
    public double start;

    /**
     * The angular extent of the arc in degrees.
     *
     * @serial
     * @since 1.2
     */
    public double extent;

    /**
     * Constructs a new OPEN arc, initialized to location (0, 0),
     * size (0, 0), angular extents (start = 0, extent = 0).
     *
     * @since 1.2
     */
    public Double() {
      super(OPEN);
    }

    /**
     * Constructs a new arc, initialized to location (0, 0),
     * size (0, 0), angular extents (start = 0, extent = 0), and
     * the specified closure type.
     *
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Double(int type) {
      super(type);
    }

    /**
     * Constructs a new arc, initialized to the specified location,
     * size, angular extents, and closure type.
     *
     * @param x The X coordinate of the upper-left corner of the arc's framing rectangle.
     * @param y The Y coordinate of the upper-left corner of the arc's framing rectangle.
     * @param w The overall width of the full ellipse of which this arc is a partial section.
     * @param h The overall height of the full ellipse of which this arc is a partial section.
     * @param start The starting angle of the arc in degrees.
     * @param extent The angular extent of the arc in degrees.
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Double(double x, double y, double w, double h,
        double start, double extent, int type) {
      super(type);
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.start = start;
      this.extent = extent;
    }

    /**
     * Constructs a new arc, initialized to the specified location,
     * size, angular extents, and closure type.
     *
     * @param ellipseBounds The framing rectangle that defines the outer boundary of the full
     * ellipse of which this arc is a partial section.
     * @param start The starting angle of the arc in degrees.
     * @param extent The angular extent of the arc in degrees.
     * @param type The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
     * @since 1.2
     */
    public Double(Rectangle2D ellipseBounds,
        double start, double extent, int type) {
      super(type);
      this.x = ellipseBounds.getX();
      this.y = ellipseBounds.getY();
      this.width = ellipseBounds.getWidth();
      this.height = ellipseBounds.getHeight();
      this.start = start;
      this.extent = extent;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getX() {
      return x;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getY() {
      return y;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getWidth() {
      return width;
    }

    /**
     * {@inheritDoc}
     * Note that the arc
     * <a href="Arc2D.html#inscribes">partially inscribes</a>
     * the framing rectangle of this {@code RectangularShape}.
     *
     * @since 1.2
     */
    public double getHeight() {
      return height;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getAngleStart() {
      return start;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getAngleExtent() {
      return extent;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public boolean isEmpty() {
      return (width <= 0.0 || height <= 0.0);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setArc(double x, double y, double w, double h,
        double angSt, double angExt, int closure) {
      this.setArcType(closure);
      this.x = x;
      this.y = y;
      this.width = w;
      this.height = h;
      this.start = angSt;
      this.extent = angExt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setAngleStart(double angSt) {
      this.start = angSt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setAngleExtent(double angExt) {
      this.extent = angExt;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    protected Rectangle2D makeBounds(double x, double y,
        double w, double h) {
      return new Rectangle2D.Double(x, y, w, h);
    }

    /*
     * JDK 1.6 serialVersionUID
     */
    private static final long serialVersionUID = 728264085846882001L;

    /**
     * Writes the default serializable fields to the
     * <code>ObjectOutputStream</code> followed by a byte
     * indicating the arc type of this <code>Arc2D</code>
     * instance.
     *
     * @serialData <ol> <li>The default serializable fields. <li> followed by a <code>byte</code>
     * indicating the arc type {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. </ol>
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
      s.defaultWriteObject();

      s.writeByte(getArcType());
    }

    /**
     * Reads the default serializable fields from the
     * <code>ObjectInputStream</code> followed by a byte
     * indicating the arc type of this <code>Arc2D</code>
     * instance.
     *
     * @serialData <ol> <li>The default serializable fields. <li> followed by a <code>byte</code>
     * indicating the arc type {@link #OPEN}, {@link #CHORD}, or {@link #PIE}. </ol>
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.lang.ClassNotFoundException, java.io.IOException {
      s.defaultReadObject();

      try {
        setArcType(s.readByte());
      } catch (IllegalArgumentException iae) {
        throw new java.io.InvalidObjectException(iae.getMessage());
      }
    }
  }

  private int type;

  /**
   * This is an abstract class that cannot be instantiated directly.
   * Type-specific implementation subclasses are available for
   * instantiation and provide a number of formats for storing
   * the information necessary to satisfy the various accessor
   * methods below.
   * <p>
   * This constructor creates an object with a default closure
   * type of {@link #OPEN}.  It is provided only to enable
   * serialization of subclasses.
   *
   * @see java.awt.geom.Arc2D.Float
   * @see java.awt.geom.Arc2D.Double
   */
  protected Arc2D() {
    this(OPEN);
  }

  /**
   * This is an abstract class that cannot be instantiated directly.
   * Type-specific implementation subclasses are available for
   * instantiation and provide a number of formats for storing
   * the information necessary to satisfy the various accessor
   * methods below.
   *
   * @param type The closure type of this arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
   * @see java.awt.geom.Arc2D.Float
   * @see java.awt.geom.Arc2D.Double
   * @since 1.2
   */
  protected Arc2D(int type) {
    setArcType(type);
  }

  /**
   * Returns the starting angle of the arc.
   *
   * @return A double value that represents the starting angle of the arc in degrees.
   * @see #setAngleStart
   * @since 1.2
   */
  public abstract double getAngleStart();

  /**
   * Returns the angular extent of the arc.
   *
   * @return A double value that represents the angular extent of the arc in degrees.
   * @see #setAngleExtent
   * @since 1.2
   */
  public abstract double getAngleExtent();

  /**
   * Returns the arc closure type of the arc: {@link #OPEN},
   * {@link #CHORD}, or {@link #PIE}.
   *
   * @return One of the integer constant closure types defined in this class.
   * @see #setArcType
   * @since 1.2
   */
  public int getArcType() {
    return type;
  }

  /**
   * Returns the starting point of the arc.  This point is the
   * intersection of the ray from the center defined by the
   * starting angle and the elliptical boundary of the arc.
   *
   * @return A <CODE>Point2D</CODE> object representing the x,y coordinates of the starting point of
   * the arc.
   * @since 1.2
   */
  public Point2D getStartPoint() {
    double angle = Math.toRadians(-getAngleStart());
    double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth();
    double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight();
    return new Point2D.Double(x, y);
  }

  /**
   * Returns the ending point of the arc.  This point is the
   * intersection of the ray from the center defined by the
   * starting angle plus the angular extent of the arc and the
   * elliptical boundary of the arc.
   *
   * @return A <CODE>Point2D</CODE> object representing the x,y coordinates  of the ending point of
   * the arc.
   * @since 1.2
   */
  public Point2D getEndPoint() {
    double angle = Math.toRadians(-getAngleStart() - getAngleExtent());
    double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth();
    double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight();
    return new Point2D.Double(x, y);
  }

  /**
   * Sets the location, size, angular extents, and closure type of
   * this arc to the specified double values.
   *
   * @param x The X coordinate of the upper-left corner of the arc.
   * @param y The Y coordinate of the upper-left corner of the arc.
   * @param w The overall width of the full ellipse of which this arc is a partial section.
   * @param h The overall height of the full ellipse of which this arc is a partial section.
   * @param angSt The starting angle of the arc in degrees.
   * @param angExt The angular extent of the arc in degrees.
   * @param closure The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
   * @since 1.2
   */
  public abstract void setArc(double x, double y, double w, double h,
      double angSt, double angExt, int closure);

  /**
   * Sets the location, size, angular extents, and closure type of
   * this arc to the specified values.
   *
   * @param loc The <CODE>Point2D</CODE> representing the coordinates of the upper-left corner of
   * the arc.
   * @param size The <CODE>Dimension2D</CODE> representing the width and height of the full ellipse
   * of which this arc is a partial section.
   * @param angSt The starting angle of the arc in degrees.
   * @param angExt The angular extent of the arc in degrees.
   * @param closure The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
   * @since 1.2
   */
  public void setArc(Point2D loc, Dimension2D size,
      double angSt, double angExt, int closure) {
    setArc(loc.getX(), loc.getY(), size.getWidth(), size.getHeight(),
        angSt, angExt, closure);
  }

  /**
   * Sets the location, size, angular extents, and closure type of
   * this arc to the specified values.
   *
   * @param rect The framing rectangle that defines the outer boundary of the full ellipse of which
   * this arc is a partial section.
   * @param angSt The starting angle of the arc in degrees.
   * @param angExt The angular extent of the arc in degrees.
   * @param closure The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
   * @since 1.2
   */
  public void setArc(Rectangle2D rect, double angSt, double angExt,
      int closure) {
    setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(),
        angSt, angExt, closure);
  }

  /**
   * Sets this arc to be the same as the specified arc.
   *
   * @param a The <CODE>Arc2D</CODE> to use to set the arc's values.
   * @since 1.2
   */
  public void setArc(Arc2D a) {
    setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(),
        a.getAngleStart(), a.getAngleExtent(), a.type);
  }

  /**
   * Sets the position, bounds, angular extents, and closure type of
   * this arc to the specified values. The arc is defined by a center
   * point and a radius rather than a framing rectangle for the full ellipse.
   *
   * @param x The X coordinate of the center of the arc.
   * @param y The Y coordinate of the center of the arc.
   * @param radius The radius of the arc.
   * @param angSt The starting angle of the arc in degrees.
   * @param angExt The angular extent of the arc in degrees.
   * @param closure The closure type for the arc: {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.
   * @since 1.2
   */
  public void setArcByCenter(double x, double y, double radius,
      double angSt, double angExt, int closure) {
    setArc(x - radius, y - radius, radius * 2.0, radius * 2.0,
        angSt, angExt, closure);
  }

  /**
   * Sets the position, bounds, and angular extents of this arc to the
   * specified value. The starting angle of the arc is tangent to the
   * line specified by points (p1, p2), the ending angle is tangent to
   * the line specified by points (p2, p3), and the arc has the
   * specified radius.
   *
   * @param p1 The first point that defines the arc. The starting angle of the arc is tangent to the
   * line specified by points (p1, p2).
   * @param p2 The second point that defines the arc. The starting angle of the arc is tangent to
   * the line specified by points (p1, p2). The ending angle of the arc is tangent to the line
   * specified by points (p2, p3).
   * @param p3 The third point that defines the arc. The ending angle of the arc is tangent to the
   * line specified by points (p2, p3).
   * @param radius The radius of the arc.
   * @since 1.2
   */
  public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3,
      double radius) {
    double ang1 = Math.atan2(p1.getY() - p2.getY(),
        p1.getX() - p2.getX());
    double ang2 = Math.atan2(p3.getY() - p2.getY(),
        p3.getX() - p2.getX());
    double diff = ang2 - ang1;
    if (diff > Math.PI) {
      ang2 -= Math.PI * 2.0;
    } else if (diff < -Math.PI) {
      ang2 += Math.PI * 2.0;
    }
    double bisect = (ang1 + ang2) / 2.0;
    double theta = Math.abs(ang2 - bisect);
    double dist = radius / Math.sin(theta);
    double x = p2.getX() + dist * Math.cos(bisect);
    double y = p2.getY() + dist * Math.sin(bisect);
    // REMIND: This needs some work...
    if (ang1 < ang2) {
      ang1 -= Math.PI / 2.0;
      ang2 += Math.PI / 2.0;
    } else {
      ang1 += Math.PI / 2.0;
      ang2 -= Math.PI / 2.0;
    }
    ang1 = Math.toDegrees(-ang1);
    ang2 = Math.toDegrees(-ang2);
    diff = ang2 - ang1;
    if (diff < 0) {
      diff += 360;
    } else {
      diff -= 360;
    }
    setArcByCenter(x, y, radius, ang1, diff, type);
  }

  /**
   * Sets the starting angle of this arc to the specified double
   * value.
   *
   * @param angSt The starting angle of the arc in degrees.
   * @see #getAngleStart
   * @since 1.2
   */
  public abstract void setAngleStart(double angSt);

  /**
   * Sets the angular extent of this arc to the specified double
   * value.
   *
   * @param angExt The angular extent of the arc in degrees.
   * @see #getAngleExtent
   * @since 1.2
   */
  public abstract void setAngleExtent(double angExt);

  /**
   * Sets the starting angle of this arc to the angle that the
   * specified point defines relative to the center of this arc.
   * The angular extent of the arc will remain the same.
   *
   * @param p The <CODE>Point2D</CODE> that defines the starting angle.
   * @see #getAngleStart
   * @since 1.2
   */
  public void setAngleStart(Point2D p) {
    // Bias the dx and dy by the height and width of the oval.
    double dx = getHeight() * (p.getX() - getCenterX());
    double dy = getWidth() * (p.getY() - getCenterY());
    setAngleStart(-Math.toDegrees(Math.atan2(dy, dx)));
  }

  /**
   * Sets the starting angle and angular extent of this arc using two
   * sets of coordinates. The first set of coordinates is used to
   * determine the angle of the starting point relative to the arc's
   * center. The second set of coordinates is used to determine the
   * angle of the end point relative to the arc's center.
   * The arc will always be non-empty and extend counterclockwise
   * from the first point around to the second point.
   *
   * @param x1 The X coordinate of the arc's starting point.
   * @param y1 The Y coordinate of the arc's starting point.
   * @param x2 The X coordinate of the arc's ending point.
   * @param y2 The Y coordinate of the arc's ending point.
   * @since 1.2
   */
  public void setAngles(double x1, double y1, double x2, double y2) {
    double x = getCenterX();
    double y = getCenterY();
    double w = getWidth();
    double h = getHeight();
    // Note: reversing the Y equations negates the angle to adjust
    // for the upside down coordinate system.
    // Also we should bias atans by the height and width of the oval.
    double ang1 = Math.atan2(w * (y - y1), h * (x1 - x));
    double ang2 = Math.atan2(w * (y - y2), h * (x2 - x));
    ang2 -= ang1;
    if (ang2 <= 0.0) {
      ang2 += Math.PI * 2.0;
    }
    setAngleStart(Math.toDegrees(ang1));
    setAngleExtent(Math.toDegrees(ang2));
  }

  /**
   * Sets the starting angle and angular extent of this arc using
   * two points. The first point is used to determine the angle of
   * the starting point relative to the arc's center.
   * The second point is used to determine the angle of the end point
   * relative to the arc's center.
   * The arc will always be non-empty and extend counterclockwise
   * from the first point around to the second point.
   *
   * @param p1 The <CODE>Point2D</CODE> that defines the arc's starting point.
   * @param p2 The <CODE>Point2D</CODE> that defines the arc's ending point.
   * @since 1.2
   */
  public void setAngles(Point2D p1, Point2D p2) {
    setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());
  }

  /**
   * Sets the closure type of this arc to the specified value:
   * <CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>.
   *
   * @param type The integer constant that represents the closure type of this arc: {@link #OPEN},
   * {@link #CHORD}, or {@link #PIE}.
   * @throws IllegalArgumentException if <code>type</code> is not 0, 1, or 2.+
   * @see #getArcType
   * @since 1.2
   */
  public void setArcType(int type) {
    if (type < OPEN || type > PIE) {
      throw new IllegalArgumentException("invalid type for Arc: " + type);
    }
    this.type = type;
  }

  /**
   * {@inheritDoc}
   * Note that the arc
   * <a href="Arc2D.html#inscribes">partially inscribes</a>
   * the framing rectangle of this {@code RectangularShape}.
   *
   * @since 1.2
   */
  public void setFrame(double x, double y, double w, double h) {
    setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type);
  }

  /**
   * Returns the high-precision framing rectangle of the arc.  The framing
   * rectangle contains only the part of this <code>Arc2D</code> that is
   * in between the starting and ending angles and contains the pie
   * wedge, if this <code>Arc2D</code> has a <code>PIE</code> closure type.
   * <p>
   * This method differs from the
   * {@link RectangularShape#getBounds() getBounds} in that the
   * <code>getBounds</code> method only returns the bounds of the
   * enclosing ellipse of this <code>Arc2D</code> without considering
   * the starting and ending angles of this <code>Arc2D</code>.
   *
   * @return the <CODE>Rectangle2D</CODE> that represents the arc's framing rectangle.
   * @since 1.2
   */
  public Rectangle2D getBounds2D() {
    if (isEmpty()) {
      return makeBounds(getX(), getY(), getWidth(), getHeight());
    }
    double x1, y1, x2, y2;
    if (getArcType() == PIE) {
      x1 = y1 = x2 = y2 = 0.0;
    } else {
      x1 = y1 = 1.0;
      x2 = y2 = -1.0;
    }
    double angle = 0.0;
    for (int i = 0; i < 6; i++) {
      if (i < 4) {
        // 0-3 are the four quadrants
        angle += 90.0;
        if (!containsAngle(angle)) {
          continue;
        }
      } else if (i == 4) {
        // 4 is start angle
        angle = getAngleStart();
      } else {
        // 5 is end angle
        angle += getAngleExtent();
      }
      double rads = Math.toRadians(-angle);
      double xe = Math.cos(rads);
      double ye = Math.sin(rads);
      x1 = Math.min(x1, xe);
      y1 = Math.min(y1, ye);
      x2 = Math.max(x2, xe);
      y2 = Math.max(y2, ye);
    }
    double w = getWidth();
    double h = getHeight();
    x2 = (x2 - x1) * 0.5 * w;
    y2 = (y2 - y1) * 0.5 * h;
    x1 = getX() + (x1 * 0.5 + 0.5) * w;
    y1 = getY() + (y1 * 0.5 + 0.5) * h;
    return makeBounds(x1, y1, x2, y2);
  }

  /**
   * Constructs a <code>Rectangle2D</code> of the appropriate precision
   * to hold the parameters calculated to be the framing rectangle
   * of this arc.
   *
   * @param x The X coordinate of the upper-left corner of the framing rectangle.
   * @param y The Y coordinate of the upper-left corner of the framing rectangle.
   * @param w The width of the framing rectangle.
   * @param h The height of the framing rectangle.
   * @return a <code>Rectangle2D</code> that is the framing rectangle of this arc.
   * @since 1.2
   */
  protected abstract Rectangle2D makeBounds(double x, double y,
      double w, double h);

  /*
   * Normalizes the specified angle into the range -180 to 180.
   */
  static double normalizeDegrees(double angle) {
    if (angle > 180.0) {
      if (angle <= (180.0 + 360.0)) {
        angle = angle - 360.0;
      } else {
        angle = Math.IEEEremainder(angle, 360.0);
        // IEEEremainder can return -180 here for some input values...
        if (angle == -180.0) {
          angle = 180.0;
        }
      }
    } else if (angle <= -180.0) {
      if (angle > (-180.0 - 360.0)) {
        angle = angle + 360.0;
      } else {
        angle = Math.IEEEremainder(angle, 360.0);
        // IEEEremainder can return -180 here for some input values...
        if (angle == -180.0) {
          angle = 180.0;
        }
      }
    }
    return angle;
  }

  /**
   * Determines whether or not the specified angle is within the
   * angular extents of the arc.
   *
   * @param angle The angle to test.
   * @return <CODE>true</CODE> if the arc contains the angle, <CODE>false</CODE> if the arc doesn't
   * contain the angle.
   * @since 1.2
   */
  public boolean containsAngle(double angle) {
    double angExt = getAngleExtent();
    boolean backwards = (angExt < 0.0);
    if (backwards) {
      angExt = -angExt;
    }
    if (angExt >= 360.0) {
      return true;
    }
    angle = normalizeDegrees(angle) - normalizeDegrees(getAngleStart());
    if (backwards) {
      angle = -angle;
    }
    if (angle < 0.0) {
      angle += 360.0;
    }

    return (angle >= 0.0) && (angle < angExt);
  }

  /**
   * Determines whether or not the specified point is inside the boundary
   * of the arc.
   *
   * @param x The X coordinate of the point to test.
   * @param y The Y coordinate of the point to test.
   * @return <CODE>true</CODE> if the point lies within the bound of the arc, <CODE>false</CODE> if
   * the point lies outside of the arc's bounds.
   * @since 1.2
   */
  public boolean contains(double x, double y) {
    // Normalize the coordinates compared to the ellipse
    // having a center at 0,0 and a radius of 0.5.
    double ellw = getWidth();
    if (ellw <= 0.0) {
      return false;
    }
    double normx = (x - getX()) / ellw - 0.5;
    double ellh = getHeight();
    if (ellh <= 0.0) {
      return false;
    }
    double normy = (y - getY()) / ellh - 0.5;
    double distSq = (normx * normx + normy * normy);
    if (distSq >= 0.25) {
      return false;
    }
    double angExt = Math.abs(getAngleExtent());
    if (angExt >= 360.0) {
      return true;
    }
    boolean inarc = containsAngle(-Math.toDegrees(Math.atan2(normy,
        normx)));
    if (type == PIE) {
      return inarc;
    }
    // CHORD and OPEN behave the same way
    if (inarc) {
      if (angExt >= 180.0) {
        return true;
      }
      // point must be outside the "pie triangle"
    } else {
      if (angExt <= 180.0) {
        return false;
      }
      // point must be inside the "pie triangle"
    }
    // The point is inside the pie triangle iff it is on the same
    // side of the line connecting the ends of the arc as the center.
    double angle = Math.toRadians(-getAngleStart());
    double x1 = Math.cos(angle);
    double y1 = Math.sin(angle);
    angle += Math.toRadians(-getAngleExtent());
    double x2 = Math.cos(angle);
    double y2 = Math.sin(angle);
    boolean inside = (Line2D.relativeCCW(x1, y1, x2, y2, 2 * normx, 2 * normy) *
        Line2D.relativeCCW(x1, y1, x2, y2, 0, 0) >= 0);
    return inarc ? !inside : inside;
  }

  /**
   * Determines whether or not the interior of the arc intersects
   * the interior of the specified rectangle.
   *
   * @param x The X coordinate of the rectangle's upper-left corner.
   * @param y The Y coordinate of the rectangle's upper-left corner.
   * @param w The width of the rectangle.
   * @param h The height of the rectangle.
   * @return <CODE>true</CODE> if the arc intersects the rectangle, <CODE>false</CODE> if the arc
   * doesn't intersect the rectangle.
   * @since 1.2
   */
  public boolean intersects(double x, double y, double w, double h) {

    double aw = getWidth();
    double ah = getHeight();

    if (w <= 0 || h <= 0 || aw <= 0 || ah <= 0) {
      return false;
    }
    double ext = getAngleExtent();
    if (ext == 0) {
      return false;
    }

    double ax = getX();
    double ay = getY();
    double axw = ax + aw;
    double ayh = ay + ah;
    double xw = x + w;
    double yh = y + h;

    // check bbox
    if (x >= axw || y >= ayh || xw <= ax || yh <= ay) {
      return false;
    }

    // extract necessary data
    double axc = getCenterX();
    double ayc = getCenterY();
    Point2D sp = getStartPoint();
    Point2D ep = getEndPoint();
    double sx = sp.getX();
    double sy = sp.getY();
    double ex = ep.getX();
    double ey = ep.getY();

        /*
         * Try to catch rectangles that intersect arc in areas
         * outside of rectagle with left top corner coordinates
         * (min(center x, start point x, end point x),
         *  min(center y, start point y, end point y))
         * and rigth bottom corner coordinates
         * (max(center x, start point x, end point x),
         *  max(center y, start point y, end point y)).
         * So we'll check axis segments outside of rectangle above.
         */
    if (ayc >= y && ayc <= yh) { // 0 and 180
      if ((sx < xw && ex < xw && axc < xw &&
          axw > x && containsAngle(0)) ||
          (sx > x && ex > x && axc > x &&
              ax < xw && containsAngle(180))) {
        return true;
      }
    }
    if (axc >= x && axc <= xw) { // 90 and 270
      if ((sy > y && ey > y && ayc > y &&
          ay < yh && containsAngle(90)) ||
          (sy < yh && ey < yh && ayc < yh &&
              ayh > y && containsAngle(270))) {
        return true;
      }
    }

        /*
         * For PIE we should check intersection with pie slices;
         * also we should do the same for arcs with extent is greater
         * than 180, because we should cover case of rectangle, which
         * situated between center of arc and chord, but does not
         * intersect the chord.
         */
    Rectangle2D rect = new Rectangle2D.Double(x, y, w, h);
    if (type == PIE || Math.abs(ext) > 180) {
      // for PIE: try to find intersections with pie slices
      if (rect.intersectsLine(axc, ayc, sx, sy) ||
          rect.intersectsLine(axc, ayc, ex, ey)) {
        return true;
      }
    } else {
      // for CHORD and OPEN: try to find intersections with chord
      if (rect.intersectsLine(sx, sy, ex, ey)) {
        return true;
      }
    }

    // finally check the rectangle corners inside the arc
    if (contains(x, y) || contains(x + w, y) ||
        contains(x, y + h) || contains(x + w, y + h)) {
      return true;
    }

    return false;
  }

  /**
   * Determines whether or not the interior of the arc entirely contains
   * the specified rectangle.
   *
   * @param x The X coordinate of the rectangle's upper-left corner.
   * @param y The Y coordinate of the rectangle's upper-left corner.
   * @param w The width of the rectangle.
   * @param h The height of the rectangle.
   * @return <CODE>true</CODE> if the arc contains the rectangle, <CODE>false</CODE> if the arc
   * doesn't contain the rectangle.
   * @since 1.2
   */
  public boolean contains(double x, double y, double w, double h) {
    return contains(x, y, w, h, null);
  }

  /**
   * Determines whether or not the interior of the arc entirely contains
   * the specified rectangle.
   *
   * @param r The <CODE>Rectangle2D</CODE> to test.
   * @return <CODE>true</CODE> if the arc contains the rectangle, <CODE>false</CODE> if the arc
   * doesn't contain the rectangle.
   * @since 1.2
   */
  public boolean contains(Rectangle2D r) {
    return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight(), r);
  }

  private boolean contains(double x, double y, double w, double h,
      Rectangle2D origrect) {
    if (!(contains(x, y) &&
        contains(x + w, y) &&
        contains(x, y + h) &&
        contains(x + w, y + h))) {
      return false;
    }
    // If the shape is convex then we have done all the testing
    // we need.  Only PIE arcs can be concave and then only if
    // the angular extents are greater than 180 degrees.
    if (type != PIE || Math.abs(getAngleExtent()) <= 180.0) {
      return true;
    }
    // For a PIE shape we have an additional test for the case where
    // the angular extents are greater than 180 degrees and all four
    // rectangular corners are inside the shape but one of the
    // rectangle edges spans across the "missing wedge" of the arc.
    // We can test for this case by checking if the rectangle intersects
    // either of the pie angle segments.
    if (origrect == null) {
      origrect = new Rectangle2D.Double(x, y, w, h);
    }
    double halfW = getWidth() / 2.0;
    double halfH = getHeight() / 2.0;
    double xc = getX() + halfW;
    double yc = getY() + halfH;
    double angle = Math.toRadians(-getAngleStart());
    double xe = xc + halfW * Math.cos(angle);
    double ye = yc + halfH * Math.sin(angle);
    if (origrect.intersectsLine(xc, yc, xe, ye)) {
      return false;
    }
    angle += Math.toRadians(-getAngleExtent());
    xe = xc + halfW * Math.cos(angle);
    ye = yc + halfH * Math.sin(angle);
    return !origrect.intersectsLine(xc, yc, xe, ye);
  }

  /**
   * Returns an iteration object that defines the boundary of the
   * arc.
   * This iterator is multithread safe.
   * <code>Arc2D</code> guarantees that
   * modifications to the geometry of the arc
   * do not affect any iterations of that geometry that
   * are already in process.
   *
   * @param at an optional <CODE>AffineTransform</CODE> to be applied to the coordinates as they are
   * returned in the iteration, or null if the untransformed coordinates are desired.
   * @return A <CODE>PathIterator</CODE> that defines the arc's boundary.
   * @since 1.2
   */
  public PathIterator getPathIterator(AffineTransform at) {
    return new ArcIterator(this, at);
  }

  /**
   * Returns the hashcode for this <code>Arc2D</code>.
   *
   * @return the hashcode for this <code>Arc2D</code>.
   * @since 1.6
   */
  public int hashCode() {
    long bits = java.lang.Double.doubleToLongBits(getX());
    bits += java.lang.Double.doubleToLongBits(getY()) * 37;
    bits += java.lang.Double.doubleToLongBits(getWidth()) * 43;
    bits += java.lang.Double.doubleToLongBits(getHeight()) * 47;
    bits += java.lang.Double.doubleToLongBits(getAngleStart()) * 53;
    bits += java.lang.Double.doubleToLongBits(getAngleExtent()) * 59;
    bits += getArcType() * 61;
    return (((int) bits) ^ ((int) (bits >> 32)));
  }

  /**
   * Determines whether or not the specified <code>Object</code> is
   * equal to this <code>Arc2D</code>.  The specified
   * <code>Object</code> is equal to this <code>Arc2D</code>
   * if it is an instance of <code>Arc2D</code> and if its
   * location, size, arc extents and type are the same as this
   * <code>Arc2D</code>.
   *
   * @param obj an <code>Object</code> to be compared with this <code>Arc2D</code>.
   * @return <code>true</code> if <code>obj</code> is an instance of <code>Arc2D</code> and has the
   * same values; <code>false</code> otherwise.
   * @since 1.6
   */
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    }
    if (obj instanceof Arc2D) {
      Arc2D a2d = (Arc2D) obj;
      return ((getX() == a2d.getX()) &&
          (getY() == a2d.getY()) &&
          (getWidth() == a2d.getWidth()) &&
          (getHeight() == a2d.getHeight()) &&
          (getAngleStart() == a2d.getAngleStart()) &&
          (getAngleExtent() == a2d.getAngleExtent()) &&
          (getArcType() == a2d.getArcType()));
    }
    return false;
  }
}
